home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / gui / prcgntn1.lha / Precognition / source / pcgWindow.c < prev    next >
C/C++ Source or Header  |  1992-12-23  |  23KB  |  979 lines
  1. #include <exec/types.h>
  2. #include <exec/nodes.h>
  3. #include <exec/lists.h>
  4. #include <exec/ports.h>
  5. #include <stdio.h>
  6.  
  7. #include "pcgWindow.h"
  8. #include "pcgWindowClass.h"
  9. #include "Precognition_Utils.h"
  10. #include "minmax.h"
  11. #include <proto/exec.h>
  12. #include <proto/intuition.h>
  13. #include <proto/graphics.h>
  14. #include "amigamem.h"
  15.  
  16. extern struct IntuitionBase *IntuitionBase;
  17.  
  18.  
  19. Screen *pcgWindow_GetScreen( pcgWindow *self )
  20. {
  21.    Screen *screen;
  22.    Window *iwindow;
  23.  
  24.    if (iwindow = iWindow(self))
  25.       screen = self->Window->WScreen;
  26.    else
  27.       screen = self->NewWindow.Screen;
  28.  
  29.    return screen;
  30. }
  31.  
  32.  
  33. BOOL pcgWindow_SanityCheck(  pcgWindow *self,
  34.                              Point     *location,
  35.                              Point     *size )
  36.    /* returns TRUE if location was changed. */
  37. {
  38.    Screen *screen;
  39.    BOOL loc_changed = FALSE;
  40.  
  41. /*   printf("SanityCheck before: Location=%d,%d, Size=%d,%d\n",*/
  42. /*      location->x, location->y, size->x, size->y );*/
  43.  
  44.    screen = pcgWindow_GetScreen(self);
  45.  
  46.    if (screen != NULL)
  47.    {
  48.       size->x = MIN( size->x, screen->Width );
  49.       size->y = MIN( size->y, screen->Height );
  50.  
  51.       /* size is now ok, so check location. */
  52.       if (location->x + size->x >= screen->Width)
  53.       {
  54.          location->x = screen->Width - size->x;
  55.          loc_changed = TRUE;
  56.       }
  57.       if (location->y + size->y >= screen->Height)
  58.       {
  59.          location->y = screen->Height - size->y;
  60.          loc_changed = TRUE;
  61.       }
  62.  
  63.    }
  64.  
  65.    return loc_changed;
  66. }
  67.  
  68.  
  69. Point pcgWindow_Location( pcgWindow *self )
  70. {
  71.    Point location;
  72.  
  73.    struct Window *iwindow;
  74.  
  75.    if (iwindow = iWindow(self))
  76.    {
  77.       location.x = iwindow->LeftEdge;
  78.       location.y = iwindow->TopEdge;
  79.    }
  80.    else
  81.    {
  82.       location = self->Location;
  83.    }
  84.  
  85.    return location;
  86. }
  87.  
  88.  
  89. Point pcgWindow_Size( pcgWindow *self )
  90. {
  91.    Point size;
  92.  
  93.    struct Window *iwindow;
  94.  
  95.    if (iwindow = iWindow(self))
  96.    {
  97.       size.x = iwindow->Width;
  98.       size.y = iwindow->Height;
  99.    }
  100.    else
  101.    {
  102.       size = self->Size;
  103.    }
  104.  
  105.    return size;
  106. }
  107.  
  108.  
  109.  
  110. Point pcgWindow_SetLocation( pcgWindow *self, WORD LeftEdge, WORD TopEdge )
  111. {
  112.    Point location, new_loc, size;
  113.    WORD dx, dy;
  114.    struct Window *iwindow;
  115.  
  116.    location  = Location(self);
  117.    size      = Size(self);
  118.    new_loc.x = LeftEdge;
  119.    new_loc.y = TopEdge;
  120.  
  121.    pcgWindow_SanityCheck( self, &new_loc, &size );
  122.  
  123.    /*printf("pcgWindow_SetLocation\n");*/
  124.    if (iwindow = iWindow(self))
  125.    {
  126.  
  127.       dx = new_loc.x - location.x;
  128.       dy = new_loc.y - location.y;
  129.  
  130.       MoveWindow( iwindow, dx, dy );
  131.  
  132.       self->Location.x = self->NewWindow.LeftEdge = iwindow->LeftEdge;
  133.       self->Location.y = self->NewWindow.TopEdge  = iwindow->TopEdge;
  134.    }
  135.    else
  136.    {
  137.       self->Location.x = self->NewWindow.LeftEdge = new_loc.x;
  138.       self->Location.y = self->NewWindow.TopEdge  = new_loc.y;
  139.    }
  140.  
  141.  
  142.    return self->Location;
  143. }
  144.  
  145.  
  146. Point pcgWindow_SetSize( pcgWindow *self, WORD width, WORD height )
  147. {
  148.    Point size, location, new_size;
  149.    WORD dx, dy;
  150.    struct Window *iwindow;
  151.  
  152.    new_size.x = width;
  153.    new_size.y = height;
  154.    location = Location(self);
  155.    if (pcgWindow_SanityCheck( self, &location, &new_size ))
  156.    {
  157.       /* In order to set this size, you have to first move the window. */
  158.       SetLocation( self, location.x, location.y );
  159.    }
  160.  
  161.    /*printf("pcgWindow_SetSize\n");*/
  162.    if (iwindow = iWindow(self))
  163.    {
  164.       /*printf("window is open.\n");*/
  165.  
  166.       size     = Size(self);
  167.       dx = new_size.x - size.x;
  168.       dy = new_size.y - size.y;
  169.       /*printf("size.x,y = (%d,%d), dx,dy=(%d,%d)\n", size.x, size.y, dx, dy );*/
  170.       SizeWindow( iwindow, dx, dy );
  171.       self->NewWindow.Width  = self->Size.x = iwindow->Width;
  172.       self->NewWindow.Height = self->Size.y = iwindow->Height;
  173.    }
  174.    else
  175.    {
  176.       self->Size.x = self->NewWindow.Width  = new_size.x;
  177.       self->Size.y = self->NewWindow.Height = new_size.y;
  178.    }
  179.  
  180.    return self->Size;
  181. }
  182.  
  183.  
  184. struct Window *pcgWindow_OpenWindow( pcgWindow *self )
  185. {
  186.    /*printf("pcgWindow_OpenWindow\n");*/
  187.  
  188.    if (self->Window) return self->Window;
  189.  
  190.    if (self->SharedUserPort)
  191.       self->Window = OpenWindowWithSharedUserPort( 
  192.          &self->NewWindow, self->SharedUserPort );
  193.    else  /* normal open window. */
  194.       self->Window = OpenWindow( &self->NewWindow );
  195.  
  196.    if (self->Window)
  197.    {
  198.       self->Window->UserData = (APTR) self;
  199.  
  200.       if (self->MenuStrip)
  201.          SetMenuStrip( self->Window, self->MenuStrip );
  202.    }
  203.    return self->Window;
  204. }
  205.  
  206.  
  207.  
  208. void pcgWindow_CloseWindow( pcgWindow *self )
  209. {
  210.    Window *w;
  211.    Point size, loc;
  212.  
  213.    if (w = self->Window)
  214.    {
  215.       /* Record size and location (for possible reopen). */
  216.       loc  = Location(self);
  217.       size = Size(self);
  218.  
  219.       if (w->MenuStrip) ClearMenuStrip( w );
  220.  
  221.       if (self->SharedUserPort)
  222.       {
  223.          /* Cannot simply close a SharedUserPort window, because
  224.           * Intution will deallocate the UserPort, and some other
  225.           * applications may be using them.  (Instant GURU)
  226.           */
  227.          CloseWindowWithSharedUserPort( w );
  228.       }
  229.       else
  230.          CloseWindow( w );
  231.  
  232.       self->Window = NULL;
  233.  
  234.       SetSize( self, size.x, size.y );
  235.       SetLocation( self, loc.x, loc.y );
  236.    }
  237. }
  238.  
  239. pcgWindow *pcgWindow_InteractorWindow( pcgWindow *self ) { return self; }
  240.  
  241.  
  242. Gadget *pcgWindow_FirstGadget( pcgWindow *self )
  243. {
  244.    Gadget *g;
  245.    struct Window *iwindow;
  246.  
  247.    if (iwindow = iWindow(self))
  248.    {
  249.       g = iwindow->FirstGadget;
  250.    }
  251.    else
  252.    {
  253.       g = self->NewWindow.FirstGadget;
  254.    }
  255.    return g;
  256. }
  257.  
  258.  
  259. USHORT pcgWindow_nGadgets( pcgWindow *self )
  260. {
  261.    Gadget *g;
  262.    USHORT count = 0;
  263.  
  264.    for (g = FirstGadget(self); g!=NULL; g=g->NextGadget )
  265.       count++;
  266.  
  267.    return count;
  268. }
  269.  
  270.  
  271. ULONG pcgWindow_IDCMPFlags( pcgWindow *self )
  272. {
  273.    struct Window *iwindow;
  274.  
  275.    if (iwindow=iWindow(self))
  276.       return iwindow->IDCMPFlags;
  277.    else
  278.       return self->NewWindow.IDCMPFlags;
  279. }
  280.  
  281.  
  282. USHORT pcgWindow_ClaimEvent( pcgWindow *self, IntuiMessage *event )
  283. {
  284.    struct Window *iwindow;
  285.    USHORT response = 0;
  286.    Interactor *iactor;
  287.  
  288.    if (iwindow = iWindow(self))
  289.    {
  290.       if (event->IDCMPWindow = iwindow)
  291.       {
  292.          response = RESPONDED;
  293.  
  294.          for (iactor = self->FirstInteractor; iactor!=NULL; iactor=iactor->Next)
  295.          {
  296.             response |= ClaimEvent(iactor, event);
  297.             if (response & CONSUMED_EVENT)
  298.                break;
  299.          }
  300.       }
  301.    }
  302.    return response;
  303. }
  304.  
  305.  
  306. void pcgWindow_AddGraphicObject( pcgWindow      *window,
  307.                                  GraphicObject   *graphic )
  308. {
  309.    GraphicObject *g;
  310.  
  311.    if (window->FirstGraphic)
  312.    {
  313.       for (g = window->FirstGraphic;
  314.            g->Next != NULL;
  315.            g = g->Next );
  316.  
  317.       g->Next = graphic;
  318.    }
  319.    else
  320.       window->FirstGraphic = graphic;
  321. }
  322.  
  323. void pcgWindow_RemoveGraphicObject( pcgWindow      *window,
  324.                                     GraphicObject  *graphic )
  325. {
  326.    GraphicObject *g;
  327.  
  328.    if (window->FirstGraphic)
  329.    {
  330.       if (window->FirstGraphic == graphic)
  331.       {
  332.          window->FirstGraphic = graphic->Next;
  333.       }
  334.       else
  335.       {
  336.          for(  g  = window->FirstGraphic;
  337.                g != NULL;
  338.                g  = g->Next )
  339.          {
  340.             if (g->Next == graphic)
  341.             {
  342.                g->Next = graphic->Next;
  343.                break;
  344.             }
  345.          }
  346.       }
  347.    }
  348.    graphic->Next = NULL;
  349. }
  350.  
  351.  
  352. void pcgWindow_AddInteractor( pcgWindow  *window,
  353.                               Interactor   *interactor )
  354. {
  355.    Interactor    *iactor;
  356.    ULONG          flags;
  357.    struct Window *iwindow;
  358.  
  359.    SetInteractorWindow( interactor, window );
  360.  
  361.    if (nGadgets(interactor)) /* Interactor has gadget(s) */
  362.    {
  363.       if (iwindow = iWindow(window))
  364.       {
  365.          AddGList( iwindow, FirstGadget(interactor),
  366.             (USHORT) ~0, nGadgets(interactor), NULL );
  367.       }
  368.       else
  369.       {
  370.          /* Add Gadgets to last gadget of window. */
  371.          if (window->NewWindow.FirstGadget)
  372.          {
  373.             ChainGadgets( window->NewWindow.FirstGadget,
  374.                           FirstGadget(interactor) );
  375.          }
  376.          else
  377.             window->NewWindow.FirstGadget = FirstGadget(interactor);
  378.  
  379.       }
  380.    }
  381.  
  382.    /* add this interactor to chain of interactors. */
  383.    if (window->FirstInteractor)
  384.    {
  385.       for (iactor = window->FirstInteractor;
  386.            iactor->Next != NULL;
  387.            iactor = iactor->Next );
  388.  
  389.       iactor->Next = interactor;
  390.    }
  391.    else
  392.       window->FirstInteractor = interactor;
  393.  
  394.    /* Add IDCMP flags */
  395.  
  396.    flags = IDCMPFlags( window ) | IDCMPFlags( interactor );
  397.    SetIDCMPFlags( window, flags );
  398.  
  399.    /*printf("AddIActor: %s IDCMPFlags=%d\n",*/
  400.    /*   ClassName( interactor ), IDCMPFlags(interactor) );*/
  401. }
  402.  
  403.  
  404. ULONG pcgWindow_SetIDCMPFlags( pcgWindow *self, ULONG newflags )
  405. {
  406.    struct Window *iwindow;
  407.    self->NewWindow.IDCMPFlags = newflags;
  408.  
  409.    /*printf("SetIDCMPFlags: %d\n", newflags );*/
  410.    if (iwindow = iWindow(self)) /* window is open */
  411.    {
  412.       ModifyIDCMP( iwindow, newflags );
  413.    }
  414.  
  415.    return IDCMPFlags(self);
  416. }
  417.  
  418.  
  419.  
  420. struct RastPort *pcgWindow_RPort( pcgWindow *self )
  421. {
  422.    if (self->Window)
  423.       return self->Window->RPort;
  424.    return NULL;
  425. }
  426.  
  427.  
  428.  
  429. void pcgWindow_Refresh( pcgWindow *window )
  430. {
  431.    GraphicObject     *graphic;
  432.    Interactor        *interactor;
  433.    RastPort          *rport;
  434.    struct Window     *iwindow;
  435.  
  436.    if (iwindow = iWindow(window))
  437.    {
  438.       RefreshWindowFrame(iwindow);
  439.  
  440.       rport = RPort( window );
  441.  
  442.       /* Draw window graphics */
  443.       for( graphic = window->FirstGraphic;
  444.            graphic != NULL;
  445.            graphic = graphic->Next )
  446.       {
  447.          Render( graphic, rport );
  448.       }
  449.  
  450.       /* Draw interactors */
  451.       for ( interactor  = window->FirstInteractor;
  452.             interactor != NULL;
  453.             interactor  = interactor->Next )
  454.       {
  455.          Refresh( interactor );
  456.       }
  457.  
  458.    }
  459. }
  460.  
  461.  
  462. BOOL pcgWindow_Activate( pcgWindow *self, BOOL activate )
  463. {
  464.    struct Window *iwindow;
  465.  
  466.    if (iwindow = iWindow(self))
  467.    {
  468.       if (activate)
  469.       {
  470.          ActivateWindow( iwindow );
  471.       }
  472.    }
  473.    return isActive(self);
  474. }
  475.  
  476.  
  477.  
  478. #define DONT_CHANGE_SCREEN_TITLE ((char*)-1)
  479.  
  480. BOOL pcgWindow_SetTitle( pcgWindow *self,
  481.                          char      *title )
  482. {
  483.    struct Window *iwindow;
  484.    char *t;
  485.    
  486.    Afree( Title(self) );
  487.    t = Astrdup(title);
  488.    
  489.    if (iwindow = iWindow(self))
  490.    {
  491.       SetWindowTitles( iwindow, t, DONT_CHANGE_SCREEN_TITLE );
  492.    }
  493.  
  494.    self->NewWindow.Title = t;
  495.    return TRUE;
  496. }
  497.  
  498. char *pcgWindow_Title( pcgWindow *self )
  499. {
  500.    return (char*) self->NewWindow.Title;
  501. }
  502.  
  503. struct Window *pcgWindow_iWindow( pcgWindow *self )
  504. {
  505.    return self->Window;
  506. }
  507.  
  508.  
  509. struct Window *pcgOpenWindow( pcgWindow *self )
  510. {
  511.    struct pcgWindowClass *class;
  512.    struct Window *result = NULL;
  513.  
  514.    /*printf("pcgOpenWindow\n");*/
  515.  
  516.    if (class = (struct pcgWindowClass *) self->isa)
  517.    {
  518.       if (class->OpenWindow)
  519.          result = (*class->OpenWindow)( self );
  520.    }
  521.  
  522.    if (result)
  523.       Refresh(self);
  524.       
  525.    return result;
  526. }
  527.  
  528.  
  529. void pcgCloseWindow( pcgWindow *self )
  530. {
  531.    struct pcgWindowClass *class;
  532.  
  533.    if (class = (struct pcgWindowClass *) self->isa)
  534.    {
  535.       if (class->CloseWindow)
  536.          (*class->CloseWindow)( self );
  537.    }
  538. }
  539.  
  540.  
  541. struct Window *iWindow( pcgWindow *self )
  542. {
  543.    struct pcgWindowClass *class;
  544.    struct Window *result = NULL;
  545.  
  546.    if (class = (struct pcgWindowClass *) self->isa)
  547.    {
  548.       if (class->iWindow)
  549.          result = (*class->iWindow)( self );
  550.    }
  551.    return result;
  552. }
  553.  
  554. RastPort *RPort( pcgWindow *self )
  555. {
  556.    struct pcgWindowClass *class;
  557.    struct RastPort *result = NULL;
  558.  
  559.    if (class = (struct pcgWindowClass *) self->isa)
  560.    {
  561.       if (class->RPort)
  562.          result = (*class->RPort)( self );
  563.    }
  564.    return result;
  565. }
  566.  
  567.  
  568. ULONG SetIDCMPFlags( pcgWindow *self, ULONG flags )
  569. {
  570.    struct pcgWindowClass *class;
  571.  
  572.    if (class = (struct pcgWindowClass *) self->isa)
  573.    {
  574.       if (class->SetIDCMPFlags)
  575.          flags = (*class->SetIDCMPFlags)( self, flags );
  576.    }
  577.    return flags;
  578. }
  579.  
  580.  
  581. void AddGraphicObject( pcgWindow *self, GraphicObject *graphic )
  582. {
  583.    struct pcgWindowClass *class;
  584.  
  585.    if (class = (struct pcgWindowClass *) self->isa)
  586.    {
  587.       if (class->AddGraphicObject)
  588.          (*class->AddGraphicObject)( self, graphic );
  589.    }
  590. }
  591.  
  592. void RemoveGraphicObject( pcgWindow *self, GraphicObject *graphic )
  593. {
  594.    struct pcgWindowClass *class;
  595.  
  596.    if (class = (struct pcgWindowClass *) self->isa)
  597.    {
  598.       if (class->RemoveGraphicObject)
  599.          (*class->RemoveGraphicObject)( self, graphic );
  600.    }
  601. }
  602.  
  603. void AddInteractor( pcgWindow *self, Interactor *interactor )
  604. {
  605.    struct pcgWindowClass *class;
  606.  
  607.    if (class = (struct pcgWindowClass *) self->isa)
  608.    {
  609.       if (class->AddInteractor)
  610.          (*class->AddInteractor)( self, interactor );
  611.    }
  612. }
  613.  
  614. void RemoveInteractor( pcgWindow *self, Interactor *interactor )
  615. {
  616.    struct pcgWindowClass *class;
  617.  
  618.    if (class = (struct pcgWindowClass *) self->isa)
  619.    {
  620.       if (class->RemoveInteractor)
  621.          (*class->RemoveInteractor)( self, interactor );
  622.    }
  623. }
  624.  
  625. void AddWindowPObject( pcgWindow *window, GraphicObject *obj )
  626. {
  627.    if (isa(obj, InteractorClass()))
  628.       AddInteractor(window, (Interactor*) obj);
  629.    else
  630.       AddGraphicObject(window, obj );
  631. }
  632.  
  633. void RemoveWindowPObject( pcgWindow *window, GraphicObject *obj )
  634. {
  635.    if (isa(obj, InteractorClass()))
  636.       RemoveInteractor(window, (Interactor*) obj);
  637.    else
  638.       RemoveGraphicObject(window, obj );
  639. }
  640.  
  641.  
  642.  
  643. void AddMenuStrip( pcgWindow *self, Menu *menustrip )
  644. {
  645.    struct pcgWindowClass *class;
  646.  
  647.    if (class = (struct pcgWindowClass *) self->isa)
  648.    {
  649.       if (class->AddMenuStrip)
  650.          (*class->AddMenuStrip)( self, menustrip );
  651.    }
  652. }
  653.  
  654. void RemoveMenuStrip( pcgWindow *self )
  655. {
  656.    struct pcgWindowClass *class;
  657.  
  658.    if (class = (struct pcgWindowClass *) self->isa)
  659.    {
  660.       if (class->RemoveMenuStrip)
  661.          (*class->RemoveMenuStrip)( self );
  662.    }
  663. }
  664.  
  665. void pcgWindow_RemoveIactorGadgets( pcgWindow *self,
  666.                                     Interactor *interactor )
  667. {
  668.    Gadget        *gadget, *prev_gadget, *next_gadget, *last_gadget;
  669.    USHORT         i, ngadgets;
  670.    struct Window *iwindow;
  671.  
  672.    if (gadget = FirstGadget(interactor))
  673.    {
  674.       ngadgets = nGadgets(interactor);
  675.       if (iwindow = iWindow(self)) /* window is open. */
  676.       {
  677.          RemoveGList( iwindow, gadget, ngadgets );
  678.       }
  679.       else /* window is not open. */
  680.       {
  681.          next_gadget = gadget;
  682.  
  683.          for( i=0; i<ngadgets; i++)
  684.          {
  685.             last_gadget = next_gadget;
  686.             next_gadget = next_gadget->NextGadget;
  687.          }
  688.          last_gadget->NextGadget = NULL;
  689.  
  690.          if (self->NewWindow.FirstGadget == gadget)
  691.          {
  692.             self->NewWindow.FirstGadget = next_gadget;
  693.          }
  694.          else
  695.          {
  696.             for( prev_gadget  = self->NewWindow.FirstGadget;
  697.                  prev_gadget != NULL;
  698.                  prev_gadget  = prev_gadget->NextGadget )
  699.             {
  700.                if (prev_gadget->NextGadget == gadget)
  701.                {
  702.                   prev_gadget->NextGadget = next_gadget;
  703.                   break;
  704.                }
  705.             }
  706.          }
  707.       }
  708.    }
  709.  
  710. }
  711.  
  712. void pcgWindow_RemoveInteractor( pcgWindow  *self,
  713.                                  Interactor *interactor )
  714. {
  715.    Interactor    *iactor;
  716.    ULONG          flags = 0;
  717.  
  718.    SetInteractorWindow( interactor, NULL );
  719.  
  720.    if (self->FirstInteractor)
  721.    {
  722.       if (self->FirstInteractor == interactor)
  723.          self->FirstInteractor = interactor->Next;
  724.       else
  725.       {
  726.          for(  iactor  = self->FirstInteractor;
  727.                iactor != NULL;
  728.                iactor  = iactor->Next )
  729.          {
  730.             if (iactor->Next == interactor)
  731.             {
  732.                iactor->Next = interactor->Next;
  733.                pcgWindow_RemoveIactorGadgets( self, interactor ); 
  734.                break;
  735.             }
  736.          }
  737.       }
  738.       interactor->Next = NULL;
  739.  
  740.    }
  741.  
  742.  
  743.    /* Compute needed IDCMP flags w/o this responder.        */
  744.    flags = self->IDCMPFlags;
  745.    for(  iactor  = self->FirstInteractor;
  746.          iactor != NULL;
  747.          iactor  = iactor->Next )
  748.       flags |= IDCMPFlags(iactor);
  749.  
  750.    SetIDCMPFlags( self, flags );
  751. }
  752.  
  753. BOOL pcgWindow_EnableIactor( pcgWindow *self, BOOL enable )
  754. {
  755.    Window      *iwindow;
  756.    Interactor  *iactor;
  757.    Gadget      *gadget;
  758.    Menu        *menu;
  759.    UWORD        mcount;
  760.  
  761.    if (iwindow = self->Window)
  762.    {
  763.       iactor = self->FirstInteractor;
  764.       gadget = (iactor) ? FirstGadget(iactor) : NULL;
  765.  
  766.       if (enable)
  767.       {
  768.          if (gadget)
  769.             AddGList( iwindow, gadget, nGadgets(self), -1, NULL );
  770.  
  771.          SetIDCMPFlags( self, self->NewWindow.IDCMPFlags );
  772.          /* enable menus. */
  773.          for( menu  = iwindow->MenuStrip, mcount=0;
  774.               menu != NULL;
  775.               menu  = menu->NextMenu, mcount++ )
  776.             OnMenu( iwindow, mcount | (NOITEM<<5) );
  777.  
  778.         ClearPointer( iwindow );
  779.  
  780.       }
  781.       else /* disable it. */
  782.       {
  783.          if (gadget) 
  784.             RemoveGList( iwindow, gadget, -1 );
  785.  
  786.          if (self->SharedUserPort)
  787.          {
  788.             /* Can't set IDCMPport to NULL if its shared. */
  789.             ModifyIDCMP( iwindow, REFRESHWINDOW );
  790.          }
  791.          else
  792.          {
  793.             ModifyIDCMP( iwindow, 0 );
  794.          }
  795.  
  796.          SetWaitPointer( iwindow );
  797.  
  798.          /* disable menus. */
  799.          for( menu  = iwindow->MenuStrip, mcount=0;
  800.               menu != NULL;
  801.               menu  = menu->NextMenu, mcount++ )
  802.             OffMenu( iwindow, mcount | (NOITEM<<5) );
  803.  
  804.       }
  805.    }
  806.    else return FALSE;
  807. }
  808.  
  809.  
  810. void pcgWindow_AddMenuStrip( pcgWindow *window, Menu *menustrip )
  811. {
  812.    if (window->MenuStrip) /* window already has a menu */
  813.    {
  814.       RemoveMenuStrip(window);
  815.    }
  816.  
  817.    window->MenuStrip = menustrip;
  818.    if (window->Window) /* Window is open */
  819.    {
  820.       SetMenuStrip(window->Window, menustrip);
  821.    }
  822. }
  823.  
  824.  
  825. void pcgWindow_RemoveMenuStrip( pcgWindow *window )
  826. {
  827.    window->MenuStrip = NULL;
  828.    if (window->Window) /* its open. */
  829.    {
  830.       ClearMenuStrip(window->Window);
  831.    }
  832. }
  833.  
  834. void pcgWindow_Erase( pcgWindow *self )
  835. {
  836.    Window    *window;
  837.    RastPort  *rport;
  838.  
  839.    window = iWindow(self);
  840.    rport  = RPort(self);
  841.  
  842.    SetDrMd ( rport, JAM2 );
  843.    SetAPen ( rport, 0 );
  844.    RectFill( rport, 0,0, window->Width, window->Height );
  845. }
  846.  
  847.  
  848.  
  849. void pcgWindow_Render( pcgWindow *self, RastPort *dontcare )
  850. {
  851.    pcgWindow_Erase( self );
  852.    Refresh ( self );
  853. }
  854.  
  855. BOOL pcgWindow_elaborated = FALSE;
  856.  
  857. struct pcgWindowClass pcgWindow_Class;
  858.  
  859.  
  860.  
  861. void pcgWindowClass_Init( struct pcgWindowClass *class )
  862. {
  863.    InteractorClass_Init( (struct InteractorClass *) class );
  864.    class->isa                 = InteractorClass();
  865.    class->ClassName           = "pcgWindow";
  866.    class->CleanUp             = NULL; 
  867.  
  868.    class->Location            = pcgWindow_Location;
  869.    class->SetLocation         = pcgWindow_SetLocation;
  870.    class->Size                = pcgWindow_Size;
  871.    class->AskSize             = NULL;
  872.    class->SetSize             = pcgWindow_SetSize;
  873.    /*class->SizeFlags           = GraphicObject_SizeFlagsAll;*/
  874.    class->Render              = pcgWindow_Render;
  875.    class->InteractorWindow    = pcgWindow_InteractorWindow;
  876.    class->SetInteractorWindow = NULL;
  877.    class->FirstGadget         = pcgWindow_FirstGadget;
  878.    class->nGadgets            = pcgWindow_nGadgets;
  879.    class->IDCMPFlags          = pcgWindow_IDCMPFlags;
  880.    class->ClaimEvent          = pcgWindow_ClaimEvent;
  881.    class->Respond             = NULL;
  882.    class->Refresh             = pcgWindow_Refresh;
  883.    class->EnableIactor              = pcgWindow_EnableIactor;
  884. /*   class->isEnabled           = pcgWindow_isEnabled;*/
  885.    class->Activate            = pcgWindow_Activate;
  886.    class->isActive            = NULL; /* pcgWindow_isActive;*/
  887.    class->SetTitle            = pcgWindow_SetTitle;
  888.    class->Title               = pcgWindow_Title;
  889.  
  890.    class->OpenWindow          = pcgWindow_OpenWindow;
  891.    class->CloseWindow         = pcgWindow_CloseWindow;
  892.    class->iWindow             = pcgWindow_iWindow;
  893.    class->RPort               = pcgWindow_RPort;
  894.    class->SetIDCMPFlags       = pcgWindow_SetIDCMPFlags;
  895.    class->AddGraphicObject    = pcgWindow_AddGraphicObject;
  896.    class->RemoveGraphicObject = pcgWindow_RemoveGraphicObject;
  897.    class->AddInteractor       = pcgWindow_AddInteractor;
  898.    class->RemoveInteractor    = pcgWindow_RemoveInteractor;
  899.    class->AddMenuStrip        = pcgWindow_AddMenuStrip;
  900.    class->RemoveMenuStrip     = pcgWindow_RemoveMenuStrip;
  901. }
  902.  
  903.  
  904. struct pcgWindowClass *pcgWindowClass( void )
  905. {
  906.    if (! pcgWindow_elaborated)
  907.    {
  908.       pcgWindowClass_Init( &pcgWindow_Class );
  909.       pcgWindow_elaborated = TRUE;
  910.    }
  911.  
  912.    return &pcgWindow_Class;
  913. }
  914.  
  915.  
  916.  
  917. void pcgWindow_Init( pcgWindow     *self,
  918.                      UWORD          leftedge,
  919.                      UWORD          topedge,
  920.                      UWORD          width,
  921.                      UWORD          height,
  922.                      UWORD          minwidth,
  923.                      UWORD          minheight,
  924.                      UWORD          maxwidth,
  925.                      UWORD          maxheight,
  926.                      char          *title,
  927.                      ULONG          IDCMPFlags,
  928.                      ULONG          flags,
  929.                      struct Screen *screen )
  930. {
  931.  
  932.    Interactor_Init( self );
  933.  
  934.    self->isa                     = pcgWindowClass();
  935.    self->Window                  = NULL;
  936.    self->FirstInteractor         = NULL;
  937.    self->FirstGraphic            = NULL;
  938.    self->SharedUserPort          = NULL;
  939.    self->MenuStrip               = NULL;
  940.  
  941.    self->NewWindow.BlockPen      = 1;
  942.    self->NewWindow.DetailPen     = 0;
  943.    self->NewWindow.IDCMPFlags    = self->IDCMPFlags = IDCMPFlags;
  944.    self->NewWindow.Flags         = flags;
  945.    self->NewWindow.FirstGadget   = NULL;
  946.    self->NewWindow.CheckMark     = NULL;
  947.    self->NewWindow.Title         = NULL; 
  948.    self->NewWindow.BitMap        = NULL;
  949.    self->NewWindow.MinWidth      = minwidth;
  950.    self->NewWindow.MinHeight     = minheight;
  951.    self->NewWindow.MaxWidth      = maxwidth;
  952.    self->NewWindow.MaxHeight     = maxheight;
  953.    if (screen)
  954.    {
  955.       self->NewWindow.Type = CUSTOMSCREEN;
  956.       self->NewWindow.Screen = screen;
  957.    }
  958.    else
  959.    {
  960.       self->NewWindow.Type   = WBENCHSCREEN;
  961.       self->NewWindow.Screen = NULL;
  962.    }
  963.  
  964.    /*
  965.    ** Have to have an initial size before you can call
  966.    ** SetSize or SetLocation
  967.    */
  968.    self->Location.x = self->NewWindow.LeftEdge = 0;
  969.    self->Location.y = self->NewWindow.TopEdge  = 0;
  970.    self->Size.x     = self->NewWindow.Width    = 0;
  971.    self->Size.y     = self->NewWindow.Height   = 0;
  972.  
  973.    SetSize( self, width, height );
  974.    SetLocation( self, leftedge, topedge );
  975.    SetTitle( self, title );
  976. }
  977.  
  978.  
  979.